Lectures/Theme 1 - Python Programming/Lecture 3 - Statements, Files/Lecture 3 - Statements, Files.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lecture 3 Statements, Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- [3.1 Statements](#section1)\n",
    "    - [3.1.1 if, else, elif Statements](#section2)\n",
    "    - [3.1.2 for Loops](#section3)\n",
    "    - [3.1.3 while Loops](#section4)\n",
    "    - [3.1.4 break, continue, pass Statements](#section5)\n",
    "- [3.2 Files](#section6)\n",
    "- [3.3 Appendix: Python Interpreter](#section7)\n",
    "- [References](#section8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3.1 Statements <a id=\"section1\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python code can be decomposed into **modules**, **statements**, **expressions**, and **objects**, as follows:\n",
    "1. Programs are composed of modules.\n",
    "2. Modules contain statements.\n",
    "3. Statements contain expressions.\n",
    "4. Expressions create and process objects.\n",
    "\n",
    "> ***Modules*** are Python files that contain Python statements; the files can be used by other programs. Modules are also often called scripts.\n",
    "\n",
    "> ***Statements*** are complete sections of code that perform an action, such as assignment statements, print statements, if statements, for statements and others. They are the smallest executable unit of code. \n",
    "\n",
    "> ***Expressions*** are part of statements that return a value, such as variables, operators, or functions calls. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1.1 if, else, elif Statements <a id=\"section2\"/>\n",
    "\n",
    "In Python, `if` statements allow us to instruct the program to perform alternative actions, based on one or several tests. This provides a means for introducing logic in our codes, and it can be interpreted as \"if this case happens, then perform this action\".\n",
    "\n",
    "`if` is a ***compound statement,*** since it may contain other statements in its syntax. Also, the `if` statement is referred to as a ***conditional*** statement.\n",
    "\n",
    "The `if` statement takes the form of an `if test`, which can be followed by one or more optional `elif (else if) tests`, and\n",
    "a final optional `else test`. Each of the tests has an associated block of nested statements, indented under a header line."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic if Test\n",
    "\n",
    "In its simplest form, the `if` statement has the following syntax:\n",
    "    \n",
    "    if test1:\n",
    "        statements -> perform action 1\n",
    "\n",
    "The `if` statement is used to perform a test and control whether or not the statements block of code is executed.\n",
    "- The first line is a header line, it opens with `if` statement and ends with a colon (omitting the colon at the end of `if` statement is one of the most common mistakes by beginner programmers in Python). The output of the `if` test is a *Boolean* variable (i.e., *True* or *False*).   \n",
    "- The block of code is indented under the header and contains one or more statements that are executed if the test is True."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "105 is high\n"
     ]
    }
   ],
   "source": [
    "x = 105\n",
    "\n",
    "if x > 100:\n",
    "    print(x, 'is high')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 105\n",
    "\n",
    "if x < 50:\n",
    "    print(x, 'is high')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 is low\n"
     ]
    }
   ],
   "source": [
    "y = 20\n",
    "\n",
    "if y < 50:\n",
    "    print (y, 'is low')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It is true!\n"
     ]
    }
   ],
   "source": [
    "if True:\n",
    "    print('It is true!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "if False:\n",
    "    print('It is true!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Therefore, the statements indented under an `if` line will be executed only if the first line returns a Boolean `True` value. As we mentioned earlier, any nonzero number or nonempty array returns a Boolean `True`, and 0 or an empty array returns a `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It is true!\n",
      "It is also true!\n"
     ]
    }
   ],
   "source": [
    "if 1:\n",
    "    print('It is true!')\n",
    "    \n",
    "if 5:\n",
    "    print('It is also true!')\n",
    "    \n",
    "if 0:\n",
    "    print('It is not true!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### if - else Tests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's add in additional logic by using the `else` statement. \n",
    "\n",
    "Check this example. Since we assigned a Boolean `False` to the variable `x`, the `if x:` line returns False, and as a result the statement indented under `if` will not be executed. In the case when the `if` test is False, the code after `else` is executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is printed when x is False\n"
     ]
    }
   ],
   "source": [
    "x = False\n",
    "\n",
    "if x:\n",
    "    print('This is printed when x is True!')\n",
    "else:\n",
    "    print('This is printed when x is False')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are more examples of using `else` to execute a block of code when an `if` test is *not* true. Note that:\n",
    "- `else` is always attached to `if`, and it cannot be used as a standalone test.\n",
    "- `else` allows to specify an alternative to execute when the `if` is False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "43 is low\n"
     ]
    }
   ],
   "source": [
    "num = 43\n",
    "\n",
    "if num > 100:\n",
    "    print(num, 'is high')\n",
    "else:\n",
    "    print(num, 'is low')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "134 is high\n"
     ]
    }
   ],
   "source": [
    "num = 134\n",
    "\n",
    "if num > 100:\n",
    "    print(num, 'is high')\n",
    "else:\n",
    "    print(num, 'is low')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### if - elif - else Tests\n",
    "\n",
    "We can use `elif` to specify additional tests, when we want to provide several alternative cases, each with its own test. `elif` is short for \"else if\" and it is always associated with an `if`. If there is an `else` test in the code, `elif` must come before `else`.\n",
    "\n",
    "The general form for is:\n",
    "\n",
    "    if test1:\n",
    "        statements -> perform action 1\n",
    "    elif test2:\n",
    "        statements -> perform action 2\n",
    "    else: \n",
    "        statements -> perform action 3\n",
    "        \n",
    "The above compound statement can be interpreted as: if the case in test 1 happens, perform action 1. Else, if the case in test 2 happens, perform action 2. Or else, if none of the above cases happen, perform action 3.\n",
    "\n",
    "That is, Python executes the statements nested under the `elif` test if the statements before the test are not True, and the statements under the `else` test are executed only when none of the `elifs` is True.\n",
    "\n",
    "Both the `elif` and `else` parts are optional and they may be omitted, as well as there may be more than one statement nested in each section.\n",
    "\n",
    "The words `if`, `elif`, and `else` line up vertically, and have the same indentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "68 is medium\n"
     ]
    }
   ],
   "source": [
    "z = 68\n",
    "    \n",
    "if z > 100:\n",
    "    print(z, 'is high')\n",
    "elif z > 50:\n",
    "    print(z, 'is medium')\n",
    "else:\n",
    "    print(z, 'is low')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30 is low\n"
     ]
    }
   ],
   "source": [
    "z = 30\n",
    "    \n",
    "if z > 100:\n",
    "    print(z, 'is high')\n",
    "elif z > 50:\n",
    "    print(z, 'is medium')\n",
    "else:\n",
    "    print(z, 'is low')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to the bank!\n"
     ]
    }
   ],
   "source": [
    "location = 'Bank'\n",
    "\n",
    "if location == 'Auto Shop':\n",
    "    print('Welcome to the Auto Shop!')\n",
    "elif location == 'Bank':\n",
    "    print('Welcome to the bank!')\n",
    "else:\n",
    "    print('Where are you?')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next example we use the `input()` function to enter text using the keyboard (press the `Enter` key to confirm it)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your name:  Joe\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome Joe!\n"
     ]
    }
   ],
   "source": [
    "person = input(\"Enter your name: \")\n",
    "# E.g., enter Joe\n",
    "\n",
    "if person == 'Joe':\n",
    "    print('Welcome Joe!')\n",
    "else:\n",
    "    print(\"Welcome, Joe will be with you shortly?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean Operators to Make Complex Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can create more complex conditional statements with Boolean operators like **and** and **or**, or use comparators like < and >."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40 is in the labor force\n"
     ]
    }
   ],
   "source": [
    "age = 40\n",
    "\n",
    "if age > 65 or age < 16:\n",
    "    print(age, 'is outside the labor force')\n",
    "else:\n",
    "    print(age, 'is in the labor force')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We saw in the examples above that we can use `==` to check if two objects are the same. Similarly, we can use an exclamation point: `!=` to check if two objects are not the same. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome, what's your name?\n"
     ]
    }
   ],
   "source": [
    "person = 'Jim'\n",
    "\n",
    "if person != 'Joe':\n",
    "    print(\"Welcome, what's your name?\")\n",
    "else:\n",
    "    print('Welcome Joe!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The if - else Ternary Expression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python also has an ***if - else ternary expression*** with the following syntax:\n",
    "\n",
    "    a if condition else b\n",
    "    \n",
    "In the above expression, first the condition is evaluated, and afterward either a or b is returned based on the Boolean value of the condition."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's reconsider the `if-else` example that we saw earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "43 is low\n"
     ]
    }
   ],
   "source": [
    "num = 43\n",
    "\n",
    "if num > 100:\n",
    "    print(num, 'is high')\n",
    "else:\n",
    "    print(num, 'is low')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The corresponding `if-else` ternary expression is as follows. It allows to reduce the above 4 lines of code into 1 line. Based on the value of the condition `num > 100`, if the condition is True then `print(num, 'is high')` is executed, and if the condition is False then `print(num, 'is low')` is executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "43 is low\n"
     ]
    }
   ],
   "source": [
    "print(num, 'is high') if num > 100 else print(num, 'is low')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Handling Case Switch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you’ve used languages like C, Pascal, or MATLAB, and if you are interested to know if there us a *switch* or *case* statement in Python that selects an action based on a variable’s value, there aren't. Instead, in Python we can code multiway branching as a series of if-elif tests.\n",
    "\n",
    "An example is shown below. Note again that we can use as many `elif` statements as we want, but there can be only one `else` statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.75\n"
     ]
    }
   ],
   "source": [
    "choice = 'ham'\n",
    "\n",
    "if choice == 'spam': \n",
    "    print(2.25)\n",
    "elif choice == 'ham':\n",
    "    print(1.75)\n",
    "elif choice == 'eggs':\n",
    "    print(0.75)\n",
    "elif choice == 'bacon':\n",
    "    print(1.10)\n",
    "else:\n",
    "    print('Bad choice')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although, it may be more convenient to create a dictionary to handle case switching instead of if-elif-else especially when there are many cases involved. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.75\n"
     ]
    }
   ],
   "source": [
    "branch = {'spam': 2.25, 'ham': 1.75, 'eggs': 0.75, 'bacon': 1.10}\n",
    "\n",
    "choice = 'eggs'\n",
    "\n",
    "if choice in branch:\n",
    "    print(branch[choice])\n",
    "else:\n",
    "    print('Bad choice')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indentation Rules\n",
    "\n",
    "Python uses indentation of statements under a header to group the statements in a nested block. In the figure below, there are 3 blocks of code, each having a header line. Note that Block 1 is nested under Block 0, and it is indented further to the right of Block 0. Then, Block 2 is nested under Block 1, and it is intended even further to the right of Block 1.\n",
    "\n",
    "<img style=\"float: left; height:270px; width:auto\" src=\"images/pic1.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The indentation in Python is used to detect blocks boundaries. All statements indented the same distance to the right belong to the same block of code. The block ends either when a less-indented line or the end of the file is encountered. \n",
    "\n",
    "Indentation may consist of any number of spaces, but it must be the same for all the statements in a single block. Four spaces or one tab per indentation level are commonly used, but there is no absolute standard for the number of spaces in indentation. However, it is not recommended to mix spaces and tabs for indentation within a block, because such indentation may look different in other editors and the codes can be more difficult to edit. \n",
    "\n",
    "Look at this example. It contains three blocks: the first block (Block 0, `if x:`) is not indented at all, the second (Block 1, `y = 2`) is indented four spaces under Block 0, and the third (Block 2, `print ('Block 2')` is indented eight spaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Block 2\n",
      "Block 1\n",
      "Block 0\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "if x:\n",
    "    y = 2\n",
    "    if y:\n",
    "        print('Block 2')\n",
    "    print('Block 1')\n",
    "print('Block 0')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Several common mistakes with code indentation are shown below, which result in errors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unindent does not match any outer indentation level (<tokenize>, line 6)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<tokenize>\"\u001b[1;36m, line \u001b[1;32m6\u001b[0m\n\u001b[1;33m    print('Block 1') # Error: inconsistent indentation, this line is indented 3 spaces, and ;y = 2' is indented 4 space\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m unindent does not match any outer indentation level\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "  if x: # Error: first line indented, this line belongs to Block 0 and it shouldnt be indented\n",
    "    y = 2\n",
    "      if y:  # Error: unexpected indentation, this line should have the same indentation as 'y = 2'\n",
    "        print('Block 2')\n",
    "   print('Block 1') # Error: inconsistent indentation, this line is indented 3 spaces, and 'y = 2' is indented 4 spaces\n",
    "print('Block 0')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To indent several lines of code for one tab, select the lines and the press either the `Tab` key or press the keys `Ctrl` + `]`. To unindent several lines of codes for one tab, press the keys `Ctrl` + `[`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Statement Delimiters: Lines and Continuations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python expects `if` statements to be written on a single line.\n",
    "\n",
    "The code below produces an error because the `if` statement spans on two lines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-27-b96ea93ac69a>, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-27-b96ea93ac69a>\"\u001b[1;36m, line \u001b[1;32m3\u001b[0m\n\u001b[1;33m    if num > 20 and num > 50 and\u001b[0m\n\u001b[1;37m                                 ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "num = 80\n",
    "\n",
    "if num > 20 and num > 50 and \n",
    "    num < 200 and num < 100:\n",
    "    print('Medium number')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When a statement is too long to fit on a single line, there are two ways to make it span multiple lines.\n",
    "\n",
    "The first one is to enclose the statement either in a pair of parentheses (), square brackets [], or curly braces {}. Continuation lines do not need to be indented at any level, but it is a good practice to align the lines vertically for readability.\n",
    "\n",
    "Examples are shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Medium number\n"
     ]
    }
   ],
   "source": [
    "num = 80\n",
    "\n",
    "if (num > 20 and num > 50 and \n",
    "    num < 200 and num < 100):\n",
    "    print('Medium number')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Medium number\n"
     ]
    }
   ],
   "source": [
    "# Note that the indentation is not required for continuation lines enclosed in a pair of parentheses, brackets, or braces\n",
    "num = 80\n",
    "if {num > 20 and num > 50 and \n",
    "  num < 200 and num < 100}:\n",
    "    print('Medium number')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Good', 'Bad', 'Ugly']"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [\"Good\",\n",
    "\"Bad\",\n",
    "\"Ugly\"]\n",
    "\n",
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also, statements can span multiple lines if they end in a backward slash. Although this is an older feature, and it is not generally recommended. One reason is because if there are empty spaces after the backward slash, it will result in an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Medium number\n"
     ]
    }
   ],
   "source": [
    "num = 80\n",
    "if num > 20 and num > 50 and \\\n",
    "    num < 200 and \\\n",
    "    num < 100:\n",
    "    print('Medium number')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above line continuation rules apply for any other statements and expressions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1 + 2 + 3 \\\n",
    "+4\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = (1 + 2 + 3 \n",
    "+4)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note also Python allows to write more than one noncompound statement (i.e., statements without nested statements) on the same line, separated by semicolons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "x = 5; print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python allows to write the body of a compound statement (like `if`) on the same line with the header, provided the body contains just simple (noncompound) statements (i.e., without 'elif' or 'else' tests)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Something\n"
     ]
    }
   ],
   "source": [
    "if True: print('Something')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1.2 for Loops <a id=\"section3\"/>\n",
    "\n",
    "A <code>for</code> loop acts as an iterator in Python; it goes through items that are in a *sequence* or any other iterable item. Objects that we've learned about that we can iterate over include strings, lists, tuples, and even dictionaries allows to iterate over keys or values.\n",
    "\n",
    "The general format for a <code>for</code> loop in Python is:\n",
    "\n",
    "    for item in object:\n",
    "        statements -> perform actions    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The variable name used for the `item` is completely up to the coder, so use your best judgment for choosing a name that makes sense and you will be able to understand when revisiting your code. This `item` can then be referenced inside your loop, for example if you wanted to use <code>if</code> statements to perform checks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = [1,2,3,4,5,6,7,8,9,10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for num in list1:\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add an <code>if</code> statement to check for even numbers. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for num in list1:\n",
    "    if num % 2 == 0:\n",
    "        print(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could have also put an <code>else</code> statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Odd number\n",
      "2\n",
      "Odd number\n",
      "4\n",
      "Odd number\n",
      "6\n",
      "Odd number\n",
      "8\n",
      "Odd number\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for num in list1:\n",
    "    if num % 2 == 0:\n",
    "        print(num)\n",
    "    else:\n",
    "        print('Odd number')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another common idea during a <code>for</code> loop is keeping some sort of running tally during multiple loops. For example, let's create a <code>for</code> loop that sums up the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n"
     ]
    }
   ],
   "source": [
    "# Start sum at zero\n",
    "list_sum = 0 \n",
    "\n",
    "for num in list1:\n",
    "    list_sum = list_sum + num\n",
    "\n",
    "print(list_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also we could have implemented a <code>+=</code> to perform the addition towards the sum. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n"
     ]
    }
   ],
   "source": [
    "# Start sum at zero\n",
    "list_sum = 0 \n",
    "\n",
    "for num in list1:\n",
    "    list_sum += num\n",
    "\n",
    "print(list_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use <code>for</code> loops with strings and tuples, since they are sequences, so when we iterate through them we will be accessing each item in the sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T\n",
      "h\n",
      "i\n",
      "s\n",
      " \n",
      "i\n",
      "s\n",
      " \n",
      "a\n",
      " \n",
      "s\n",
      "t\n",
      "r\n",
      "i\n",
      "n\n",
      "g\n",
      ".\n"
     ]
    }
   ],
   "source": [
    "for letter in 'This is a string.':\n",
    "    print(letter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loop through a dictionary\n",
    "d = {'k1':1,'k2':2,'k3':3}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k1\n",
      "k2\n",
      "k3\n"
     ]
    }
   ],
   "source": [
    "for item in d:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how this produces only the keys. \n",
    "\n",
    "We can also use the Dictionary methods: **.keys()**, **.values()** and **.items()**. In Python each of these methods return a *dictionary view object*. It supports operations like membership test and iteration, but its contents are not independent of the original dictionary – it is only a view. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('k1', 1), ('k2', 2), ('k3', 3)])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a dictionary view object\n",
    "d.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the `.items()` method supports iteration, we can perform *dictionary unpacking* to separate keys and values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k1\n",
      "1\n",
      "k2\n",
      "2\n",
      "k3\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# Dictionary unpacking\n",
    "for k,v in d.items():\n",
    "    print(k)\n",
    "    print(v) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to obtain a true list of keys, values, or key/value tuples, you can *cast* the view as a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['k1', 'k2', 'k3']"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(d.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['k1', 'k2', 'k3'])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Compare to \n",
    "d.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(d.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another used function is **range** which allows to quickly *generate* a list of integers, and it is often used with `for` loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index 0 Letter a\n",
      "Index 1 Letter b\n",
      "Index 2 Letter c\n",
      "Index 3 Letter d\n",
      "Index 4 Letter e\n"
     ]
    }
   ],
   "source": [
    "string = 'abcde'\n",
    "\n",
    "n = len(string)\n",
    "for i in range(n): # i in the index\n",
    "    print('Index', i, 'Letter', string[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general, range can have 3 parameters to pass: a start, a stop, and a step size. Let's see some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# To get a list out of range, we need to cast it to a list\n",
    "# Parameters: start, stop, step size\n",
    "list(range(0,101,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Default step size is 1\n",
    "# Notice that 11 is not included\n",
    "list(range(0,11))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Default start is 0\n",
    "list(range(6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **enumerate** function is another useful function to use with `for` loops. It returns both the index and item in an sequence. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index 0 Letter: a\n",
      "Index 1 Letter: b\n",
      "Index 2 Letter: c\n",
      "Index 3 Letter: d\n",
      "Index 4 Letter: e\n"
     ]
    }
   ],
   "source": [
    "string = 'abcde'\n",
    "\n",
    "for i,letter in enumerate(string):\n",
    "    print('Index', i,'Letter:', letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1.3 while Loops <a id=\"section4\"/>\n",
    "\n",
    "The <code>while</code> statement in Python is another way to perform iteration. A <code>while</code> statement will repeatedly execute a single statement or group of statements as long as the condition is true. The reason it is called a 'loop' is because the code statements are looped through over and over again until the condition is no longer met.\n",
    "\n",
    "The general format of a while loop is:\n",
    "\n",
    "    while test:\n",
    "        statements -> perform action 1\n",
    "    else:\n",
    "        statements -> peform action 2\n",
    "\n",
    "Let’s look at a few simple <code>while</code> loops in action. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is currently:  0\n",
      "x is still less than 5, adding 1 to x\n",
      "x is currently:  1\n",
      "x is still less than 5, adding 1 to x\n",
      "x is currently:  2\n",
      "x is still less than 5, adding 1 to x\n",
      "x is currently:  3\n",
      "x is still less than 5, adding 1 to x\n",
      "x is currently:  4\n",
      "x is still less than 5, adding 1 to x\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "\n",
    "while x < 5:\n",
    "    print('x is currently: ', x)\n",
    "    print('x is still less than 5, adding 1 to x')\n",
    "    x+=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also add an <code>else</code> statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is currently:  0\n",
      " x is still less than 5, adding 1 to x\n",
      "x is currently:  1\n",
      " x is still less than 5, adding 1 to x\n",
      "x is currently:  2\n",
      " x is still less than 5, adding 1 to x\n",
      "x is currently:  3\n",
      " x is still less than 5, adding 1 to x\n",
      "x is currently:  4\n",
      " x is still less than 5, adding 1 to x\n",
      "All Done!\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "\n",
    "while x < 5:\n",
    "    print('x is currently: ',x)\n",
    "    print(' x is still less than 5, adding 1 to x')\n",
    "    x+=1\n",
    "else:\n",
    "    print('All Done!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# DO NOT RUN THIS CODE!!!! \n",
    "while True:\n",
    "    print(\"I'm stuck in an infinite loop!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A quick note: If you *did* run the above cell, click on the Kernel menu above to restart the kernel!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1.4 break, continue, pass Statements <a id=\"section5\"/>\n",
    "\n",
    "We can use <code>break</code>, <code>continue</code>, and <code>pass</code> statements in our loops to add additional functionality for various cases. \n",
    "\n",
    "With the <code>break</code> and <code>continue</code> statements, the general format of the <code>while</code> loop looks like this:\n",
    "\n",
    "    while test: \n",
    "        statements -> perform action 1\n",
    "        if test: \n",
    "            break         # Exit the 'while' loop now\n",
    "            continue      # Skip the 'else' statements (if present) and go to top of the 'while' loop now \n",
    "        else:\n",
    "            statements -> perform action 2   # Run these statements when the 'if' test is False \n",
    "\n",
    "<code>break</code> and <code>continue</code> statements can appear anywhere inside the loop’s body, but they are usually nested in an <code>if</code> statement to perform an action based on some condition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s\n",
      "t\n",
      "r\n",
      "The end\n"
     ]
    }
   ],
   "source": [
    "for letter in \"string\":\n",
    "    if letter == \"i\":\n",
    "        break # exit the 'for' loop now\n",
    "    print(letter)\n",
    "\n",
    "print(\"The end\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s\n",
      "t\n",
      "r\n",
      "n\n",
      "g\n",
      "The end\n"
     ]
    }
   ],
   "source": [
    "for letter in \"string\":\n",
    "    if letter == \"i\":\n",
    "        continue # go to the top of the 'for' loop now (skip the commands following 'continue')\n",
    "    print(letter)\n",
    "\n",
    "print(\"The end\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One more example follows with an `else` statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is currently:  0\n",
      " x is still less than 5, adding 1 to x\n",
      "continuing...\n",
      "x is currently:  1\n",
      " x is still less than 5, adding 1 to x\n",
      "continuing...\n",
      "x is currently:  2\n",
      " x is still less than 5, adding 1 to x\n",
      "Breaking because x==3\n",
      "The end\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "\n",
    "while x < 5:\n",
    "    print('x is currently: ', x)\n",
    "    print(' x is still less than 5, adding 1 to x')\n",
    "    x+=1\n",
    "    if x==3:\n",
    "        print('Breaking because x==3')\n",
    "        break  # terminate the 'while' loop, go to the 'print('The end')' statement\n",
    "    else:\n",
    "        print('continuing...')\n",
    "        \n",
    "print('The end')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is currently:  0\n",
      " x is still less than 5, adding 1 to x\n",
      "continuing...\n",
      "x is currently:  1\n",
      " x is still less than 5, adding 1 to x\n",
      "continuing...\n",
      "x is currently:  2\n",
      " x is still less than 5, adding 1 to x\n",
      "Breaking because x==3\n",
      "x is currently:  3\n",
      " x is still less than 5, adding 1 to x\n",
      "continuing...\n",
      "x is currently:  4\n",
      " x is still less than 5, adding 1 to x\n",
      "continuing...\n",
      "The end\n"
     ]
    }
   ],
   "source": [
    "x=0\n",
    "\n",
    "while x < 5:\n",
    "    print('x is currently: ', x)\n",
    "    print(' x is still less than 5, adding 1 to x')\n",
    "    x+=1\n",
    "    if x==3:\n",
    "        print('Continuing to the next step')\n",
    "        continue  # Skip the rest of the lines, and go to the while loop\n",
    "    else:\n",
    "        print('continuing...')\n",
    "        \n",
    "print('The end')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Pass` is generally used as a placeholder and it does not do anything. Suppose we have a loop or a function that is not implemented yet, but we want to implement it in the future. They cannot have an empty body, because this would give an error. So, we use the `pass` statement to construct a body that does nothing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pass is just a placeholder for functionality to be added later\n",
    "sequence = {'p', 'a', 's', 's'}\n",
    "for val in sequence:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pass can be used as a placehold for a function or a class\n",
    "def my_function(arguments):\n",
    "    pass\n",
    "\n",
    "class Example:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3.2 Files <a id=\"section6\"/>\n",
    "\n",
    "Python uses file objects to interact with external files on your computer. These file objects can be any sort of file you have on your computer, such as a text file, Excel document, email, audio file, picture, etc. \n",
    "\n",
    "Python has a built-in `open` function that allows us to open and write to files. The `open` function creates a Python file object, which serves as a link to the file residing on the computer. It allows to transfer strings of data to and from the linked external file.\n",
    "\n",
    "The `open` function requires to pass two arguments: filename and processing mode. The `filename` is the name of the file, and for reading it, it is assumed that the file exists in the current working directory: if that is not the case, the `filename` should also include the path to the file. The processing `mode` can be either the string `'r'` to read the file (open for text input), `'w'` to write the file (create and open for text output), or `'a'` to append text to an existing file; also, adding `+` to the mode allows to both read and write to a file. Both the filename and mode arguments should be strings. \n",
    "\n",
    "```\n",
    "afile = open(filename, mode)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Writing to a File\n",
    "\n",
    "For example, let's create a simple text file called `test.txt` having two lines of text. The `open` function in the example below will return an object named `myfile`, which has a `write` method  for data transfer. \n",
    "\n",
    "The file `test.txt` will be saved in the current working directory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Open for text output: create an empty file\n",
    "myfile = open('test.txt','w')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write a line of text: string\n",
    "myfile.write('hello text file\\n')\n",
    "# Note that the write call returns the number of characters in the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfile.write('goodbye text file\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfile.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note also that we need to include the end-of-line terminator `\\n` in the string, otherwise the next `write` command will continue the current line.\n",
    "\n",
    "Now, click on the `test.txt` file in the Jupyter dashboard, to inspect if it looks as we expect."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use caution when opening a file for writing with `w`, as it truncates the original, meaning that the original file is deleted. Let's try the following code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfile = open('test.txt','w')\n",
    "myfile.write('This is a first line\\n')\n",
    "myfile.write('This is a second line\\n')\n",
    "myfile.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now open the file `test.txt` and you will notice that it has been overwriten."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Opening a file\n",
    "\n",
    "Let's open the file `test.txt`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Open for text input: 'r' is default mode and it can be omitted\n",
    "myfile = open('test.txt','r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is a first line\\n'"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Read the lines back one at a time\n",
    "myfile.readline()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is a second line\\n'"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Read the lines back one at a time\n",
    "myfile.readline()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Empty string: end-of-file (EOF)\n",
    "myfile.readline() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition, using the `read` method we can read the entire file into a string all at once."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is a first line\\nThis is a second line\\n'"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfile = open('test.txt')\n",
    "myfile.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or, if we use `print` the content will be displayed in a readable format without showing the `\\n`characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a first line\n",
      "This is a second line\n",
      "\n"
     ]
    }
   ],
   "source": [
    "myfile = open('test.txt')\n",
    "print(myfile.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also note that we can write the above cell into one single line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a first line\n",
      "This is a second line\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(open('test.txt').read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One confusing thing about reading files is that If we try to read the same file object twice, we'll find out that it only gets read once:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is a first line\\nThis is a second line\\n'"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfile = open('test.txt')\n",
    "myfile.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# What happens if we try to read the file again?\n",
    "myfile.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This happens because file objects remember their position, and after we read the file the first time, the reading 'cursor' was at the end of the file, and there was nothing left to read.\n",
    "\n",
    "We can reset the 'cursor' like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Seek to the start of file (index 0)\n",
    "myfile.seek(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is a first line\\nThis is a second line\\n'"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Now read again\n",
    "myfile.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you have finished using a file, it is always good practice to close it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfile.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also sometimes see another code variant, where `open` is used within a `with` statement, like in the example shown below. One advantage of this approach is that the `with` statement automatically closes the file after the block. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a first line\n",
      "This is a second line\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with open('test.txt', 'r') as myfile:\n",
    "    data = myfile.read()\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, to read files from other directories on your computer (instead of the current working directory), enter the entire file path.\n",
    "\n",
    "For Windows, one option is to use double backslashes `\\\\` so that Python doesn't treat the second `\\` as an escape character:\n",
    "\n",
    "    myfile = open('C:\\\\Users\\\\YourUserName\\\\Desktop\\\\MyFolder\\\\test.txt')\n",
    "    \n",
    "E.g., note that the `\\n` character in the string introduces an unwanted new line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\some\n",
      "ame\n"
     ]
    }
   ],
   "source": [
    "print('C:\\some\\name')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is corrected by using double backslashes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\some\\name\n"
     ]
    }
   ],
   "source": [
    "print('C:\\\\some\\\\name')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For Mac OS and Linux, use forward slashes:\n",
    "\n",
    "    myfile = open('/Users/YourUserName/MyFolder/test.txt')    \n",
    "    \n",
    "In latest Python versions `open` works with either forward slashes or backward slashes, so either is fine.\n",
    "However, the problem with the single and double slashes in the examples above is that codes written on a Windows machine will not work on Unix machines, and vice versa. Therefore, a preferred option for Windows would be to use a `raw string` and single backslashes as shown below.\n",
    "    \n",
    "    myfile = open(r'C:\\Users\\YourUserName\\Desktop\\MyFolder\\test.txt')\n",
    "\n",
    "The `raw string` form (use of `r` before the string) turns off escape characters in strings. \n",
    "\n",
    "Note that `C:\\Users\\YourUserName\\Desktop\\MyFolder\\test.txt` is an ***absolute path*** because it lists all directories on the disk `C:` to access the file `test.txt`. The path can also be a ***relative path***, where for example if we are currently in a current working directory `C:\\Users\\YourUserName\\Desktop` we can use `MyFolder\\test.txt` as a path for the `filename` relative to the current working directory."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Appending to a File\n",
    "\n",
    "Passing the argument `'a'` as a processing mode opens the file and puts the pointer at the end for appending. `'a+'` allows us to both read and write to a file. If the file does not exist, one will be created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfile = open('test.txt','a+')\n",
    "myfile.write('\\nThis is text being appended to test.txt\\n')\n",
    "myfile.write('And another line here\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a first line\n",
      "This is a second line\n",
      "\n",
      "This is text being appended to test.txt\n",
      "And another line here\n",
      "\n"
     ]
    }
   ],
   "source": [
    "myfile.seek(0)\n",
    "print(myfile.read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfile.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterating through a File\n",
    "\n",
    "When reading a file line by line, the entire file is held in the memory. Using file iterators, such as a `for` loop, is often preferred with large files. The created file object by `open` will automatically read and return one line on each loop iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a first line\n",
      "\n",
      "This is a second line\n",
      "\n",
      "\n",
      "\n",
      "This is text being appended to test.txt\n",
      "\n",
      "And another line here\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for line in open('test.txt'):\n",
    "    print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Storing Python Objects in Files: Conversions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's next consider an example where multiple Python objects are written into a text file on multiple lines. The objects need to be converted to strings, as write methods do not do any automatic to-string formatting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Introduce numbers, string, dictionary, and list objects\n",
    "S = 'Spam' \n",
    "X, Y, Z = 43, 44, 45 \n",
    "D = {'a': 1, 'b': 2}\n",
    "L = [1, 2, 3]\n",
    "\n",
    "# Create output text file\n",
    "F = open('datafile.txt', 'w') \n",
    "# The lines in the string variable S aboove should end with \\n\n",
    "F.write(S + '\\n') \n",
    "# Convert numbers to strings\n",
    "F.write('%s,%s,%s\\n' % (X, Y, Z)) \n",
    "# Convert and separate\n",
    "F.write(str(L) + '\\n' + str(D) + '\\n') \n",
    "F.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's open the file and read it. \n",
    "\n",
    "Notice that the interactive displayed output gives the exact contents, while the print operation interprets embedded end-of-line characters to render a formatted display."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Spam\\n43,44,45\\n[1, 2, 3]\\n{'a': 1, 'b': 2}\\n\""
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "content = open('datafile.txt').read() \n",
    "# String display\n",
    "content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Spam\n",
      "43,44,45\n",
      "[1, 2, 3]\n",
      "{'a': 1, 'b': 2}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# User-friendly display\n",
    "print(content) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To translate the strings in the text file into Python objects, we now have to use other conversion tools.\n",
    "\n",
    "For instance, `rstrip()` removes the end-of-line character `\\n`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Spam\\n'"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Open the file again, this time using the object named F\n",
    "F = open('datafile.txt') \n",
    "# Read the first line (see above)\n",
    "line = F.readline() \n",
    "line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Spam'"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Remove end-of-line\n",
    "s = line.rstrip() \n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next line contains the string of numbers `'43,44,45\\n'`, for which `split()` can be used to separate the numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'43,44,45\\n'"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Next line from file\n",
    "line = F.readline() \n",
    "line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['43', '44', '45\\n']"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Split on commas\n",
    "parts = line.split(',')\n",
    "parts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[43, 44, 45]"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# int() converts to integer numbers\n",
    "numbers = [int(P) for P in parts]\n",
    "numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(43, 44, 45)"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x, y, z = numbers\n",
    "x, y, z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To covert the list and dictionary we will use `eval()` which treats a string as executable code containing a Python expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'[1, 2, 3]\\n'"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line = F.readline()\n",
    "line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'[1, 2, 3]'"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line.rstrip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = eval(line)\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"{'a': 1, 'b': 2}\\n\""
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line = F.readline()\n",
    "line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 2}"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = eval(line)\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fortunately, there are simpler ways to write and read files in Python, which do not require the above conversion steps. Next, we will learn about `pickle` and `JSON`, and in another lecture we will learn how to use `pandas`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Storing Python Objects with pickle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python’s standard library `pickle` allows storing almost any Python object in a file directly, without the requirement for conversions to and from strings. To store the above list L in a file, we can pickle it directly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "F = open('newdatafile.pkl', 'wb') # 'wb' stands for writing a binary file, and it indicates that the content of the file is not text\n",
    "# Pickle any object to file\n",
    "pickle.dump(L, F) \n",
    "F.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, to read the file and get the list we simply use pickle again (a.k.a. unpickling)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load any object from file\n",
    "F = open('newdatafile.pkl', 'rb') # similarly, 'rb' stands for reading a binary file\n",
    "list1 = pickle.load(F) \n",
    "list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "F.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `pickle` module performs what is known as *object serialization*—converting objects to and from strings of bytes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Storing Python Objects with JSON"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`JSON` (stands for JavaScript Object Notation) is a newer data interchange format, which allows using stored data across programming languages (unlike `pickle` which works only with Python). On the other hand, `JSON` does not support as broad a range of Python object types as `pickle`.\n",
    "\n",
    "The following example shows translating the above dictionary D into JSON format to be saved into a file, and recreating the dictionary from the JSON format when it is loaded from the file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "FJ = open('json_datafile.text', 'w')\n",
    "# Store the object to file\n",
    "json.dump(D, FJ) \n",
    "FJ.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 2}"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_d = json.load(open('json_datafile.text'))\n",
    "new_d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3.3 Appendix (not required for quizzes and assignments) <a id=\"section7\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Interpreter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ***interpreter*** in Python is the program that executes other programs. When you run your programs in Python, the interpreter reads your programs, and carries out the instructions contained in the program. Or, we can say that the interpreter interprets your codes and enables the hardware on your computer to execute the program."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you install Python on your computer, the Python interpreter will be part of the installation, either as an executable program, or as a set of linked libraries. Note that there are several different Python installations, and depending on the type of Python installation you have on your computer, the interpreter may be implemented as a C program, a set of Java classes, or\n",
    "in another programming language. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Understanding how the programs are executed in Python can be helpful for programmers. For instance, I saved the following simple file as *module1.py*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float: left; height:180px;\" src=\"images/pic2.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When I run the file in the Command Prompt, Python executed the file, and the output of the program is `Hello world!` and `10`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float: left; height:240px;\" src=\"images/pic3.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we run programs in Python, the programs are first compiled into ***byte code***, and are afterward run by a  ***Python virtual machine (PVM)***, as shown in the figure below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float: left; height:200px;\" src=\"images/pic4.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Byte code*** is a format into which the ***source code*** (the statements in the file) is compiled by the Python interpreter. Byte-code is platform-independent (i.e., it can be run on Windows, Linux, MacOS), and it can be run more quickly than the source code program.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The byte code is stored into a file with a *.pyc* extension, which stands for compiled .py file. The *.pyc* files are saved in a subdirectory named\n",
    "\\_\\_pycache\\_\\_ located in the same directory where the source file is saved."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, the directory where *module1.py* is saved on my computer is shown below, and the \\_\\_pycache\\_\\_ subdirectory was automatically created by Python.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float: left; height:180px;\" src=\"images/pic5.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Within the subdirectory is the byte code file named *module1.cpython-36*. The name indicates that the Python installation on my computer uses the CPython interpreter, and the installed Python version is 3.6. Note that the file type is PYC file, meaning a .pyc extension."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float: left; height:140px;\" src=\"images/pic6.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Byte code is saved for speed optimization. When I run module1.py next time, Python will skip the compilation step, and it will directly load the saved .pyc byte code file. However, if the original source code file module1.py was modified, Python will re-compile and update the byte code file. Similarly, if a different version of Python is installed, a new byte code file will be created that matches the current version of Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Python virtual machine*** (PVM) is the last part of the Python interpreter. PVM executes the byte code instructions one-by-one, i.e., it is the component that runs the programs. PVM is not a separate program, and it  does not need to be installed separately: it is part of the Python installation. PVM needs a software layer to allocates physical computing resources—such as processors, memory, and storage. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python belongs to the group of **interpreted languages**, or they are also called *scripting languages* (other languages in this group are Perl, Ruby). The Python interpreter reads the statements in source files and converts them into byte code files, which are afterwards executed by the PVM. Conversely, Java, C, and C++ belong to the group of **compiled languages**. In these languages, a compiler converts the source files' statements into binary machine code, which are afterwards executed by the computer hardware. Note that byte code files are different than binary machine code files. Consequently, running Python programs is slower than running C or C++ programs, because the code is interpreted as it is executed. On the other hand, writing and testing Python programs is faster and easier than writing and testing programs with the compiled languages. (One last clarification: Python does compile source files, but the result is not a binary machine code, and because of that it is not considered a compiled language)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we mentioned earlier, there are several different implementations of the Python interpreter, such as CPython, Jython, IronPython, Stackless Python, and PyPy. CPython is the standard, original implementation of Python, Jython is a Python implementation targeted for integration with the Java programming language, IronPython was designed to allow Python programs to integrate with applications coded to work with Microsoft’s .NET Framework for Windows, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# References <a id=\"section8\"/>\n",
    "\n",
    "1. Mark Lutz, \"Learning Python,\" 5-th edition, O-Reilly, 2013. ISBN: 978-1-449-35573-9.\n",
    "2. Pierian Data Inc., \"Complete Python 3 Bootcamp,\" codes available at: [https://github.com/Pierian-Data/Complete-Python-3-Bootcamp](https://github.com/Pierian-Data/Complete-Python-3-Bootcamp)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}